Langkah Pertama ke Pengkomputeran Kuantum

Tahap Kesukaran: Pemula
Penggunaan masa QPU: 11s

Selamat datang, para penggemar! Kami sangat gembira dapat bersama anda dalam workshop ini. Matlamat utama sesi hands-on pengenalan ini adalah untuk menyediakan anda bagi perjalanan kuantum dengan 1) membimbing anda cara memasang qiskit 2) cara mencipta akaun IBM Cloud dan menyediakan api_key dan crn untuk menggunakan komputer kuantum sebenar dan 3) membuat litar kuantum pertama anda, 4) menyelesaikan kuiz keadaan kuantum dan 5) Menjalankan litar anda pada komputer kuantum sebenar dan memplot hasilnya.

1. Perkara Pertama Dahulu: Qiskit

Apa itu Qiskit

Qiskit SDK ialah tindanan perisian berprestasi tinggi yang dibina untuk membantu pembangun dan penyelidik memanfaatkan sepenuhnya kuasa komputer kuantum pada skala utiliti dan seterusnya. Teras utamanya ialah Qiskit SDK, kit pembangunan perisian sumber terbuka untuk bekerja dengan komputer kuantum pada peringkat litar kuantum yang lanjutan. Operator dan primitif. Qiskit SDK membolehkan sesiapa sahaja mendapat prestasi optimum daripada komputer kuantum sebenar menggunakan persekitaran pengkomputeran pilihan mereka.

Selain SDK, Qiskit juga merangkumi set alatan dan perkhidmatan berprestasi tinggi seperti Qiskit Runtime Service, yang membolehkan pengiraan yang dioptimumkan pada komputer kuantum IBM melalui awan menggunakan primitif yang menguruskan pengurangan ralat. Qiskit Transpiler service pula menyediakan kaedah heuristik dan dikuasakan AI yang terkini untuk meningkatkan prestasi bagi tugas-tugas pengoptimuman litar kuantum yang biasa.

Fungsi-fungsi Qiskit, sebuah katalog perkhidmatan IBM dan pihak ketiga yang memudahkan pengoptimuman beban kerja dan memanfaatkan Qiskit untuk kes penggunaan industri. Sama ada anda seorang pembangun perisian kuantum, eksperimentalis kuantum, saintis pengiraan, atau sekadar ingin bermula — rangka kerja modular dan fleksibel Qiskit membolehkan anda bekerja pada tahap abstraksi yang paling sesuai dengan keperluan anda.

Qiskit direka untuk kebolehpanjangan dan penyesuaian, supaya anda boleh menghasilkan prestasi terbaik dalam industri dan menangani masalah-masalah baharu. Pangkalan kod berprestasi tinggi bermakna Qiskit SDK berfungsi lebih pantas, menggunakan lebih sedikit memori, dan memberikan hasil yang lebih baik daripada sebelumnya. Dan Qiskit juga memperkenalkan anda kepada komuniti pengguna dan pembangun yang luas yang tidak sabar untuk menyambut anda dan membantu menjawab soalan anda. Dilancarkan pertama kali pada 2019, program Qiskit advocate ialah inisiatif bertumpukan komuniti global yang merekrut profesional dan peminat pengkomputeran kuantum dari seluruh dunia. Selama bertahun-tahun, para advocate telah menjadi pemimpin yang diiktiraf dalam komuniti kuantum. Mahu jadi pemimpin kuantum seterusnya? Jangan teragak-agak untuk memohon — di sini

Pasang Qiskit

Pertama, pastikan versi Python yang anda gunakan dalam persekitaran anda adalah python>=3.10, untuk memastikan ia serasi dengan versi Qiskit terkini yang akan kita gunakan

from platform import python_version

print(python_version())

Jika tidak demikian, anda boleh menaik tarafnya menggunakan alatan pilihan anda. Jika anda tidak pasti cara melakukannya, beberapa pilihan yang disyorkan ialah:

MacOS: Homebrew
Linux: sudo apt-get update

Panduan terperinci tentang cara menaik taraf Python bergantung pada OS anda diperincikan di sini: How to update Python

Untuk maklumat lanjut, lihat wiki QGSS (Qiskit Global Summer School) 2025: https://github.com/qiskit-community/qgss-2025/wiki/Jupyter-Notebook-Environment-(Local-and-Online)

Anda boleh mengesahkan pemasangan anda dengan menjalankan sel di bawah. Jika anda memasang dengan betul, ia akan mengembalikan versi qiskit.

# Added by doQumentation — installs the packages this notebook needs if they are missing
import importlib.util

_needed = {"numpy": "numpy", "qiskit": "qiskit"}
_missing = [pip for module, pip in _needed.items()
            if importlib.util.find_spec(module) is None]
# One at a time, so a package that fails to install does not block the others
for _pip in _missing:
    %pip install -q {_pip}
if not _missing:
    print("\u2713 All required packages are installed")

%pip install 'qiskit[visualization]'
%pip install qiskit-ibm-runtime
%pip install qiskit-aer

import qiskit

print(f"Qiskit version: {qiskit.__version__}")

Penyelesaian Masalah

Jika sel sebelumnya menunjukkan ralat, anda boleh memilih untuk memasang Qiskit dalam persekitaran maya (dua kaedah yang dicadangkan berikut). Jika tiada ralat, anda boleh abaikan sel ini dan teruskan ke sel seterusnya.

Di sini kami mencadangkan dua kaedah berbeza untuk menyediakan persekitaran maya bagi memasang Qiskit.

Menggunakan venv, seperti yang dijelaskan dalam panduan pemasangan Qiskit.
Menggunakan conda, seperti yang dijelaskan dalam video Coding with Qiskit ini.

2. Sediakan Akaun IBM Cloud Anda

Untuk menggunakan komputer kuantum sebenar, anda memerlukan api key — tiket masuk utama ke awan — dan crn — token yang akan membawa sumber anda kepada anda dengan menetapkan akaun anda.

Sediakan akaun anda seperti berikut:

Pergi ke IBM Quantum® Platform.
Pergi ke sudut kanan atas (seperti yang ditunjukkan dalam gambar di atas), cipta token API anda, dan salinnya ke lokasi yang selamat.
Dalam sel seterusnya, gantikan deleteThisAndPasteYourAPIKeyHere dengan kunci API anda.
Pergi ke sudut kiri bawah (seperti yang ditunjukkan dalam gambar di atas) dan cipta instans anda. Pastikan anda memilih pelan terbuka.
Selepas instans dicipta, salin kod CRN yang berkaitan dengannya. Anda mungkin perlu memuat semula untuk melihat instans tersebut.
Dalam sel di bawah, gantikan deleteThisAndPasteYourCRNHere dengan kod CRN anda.

Lihat panduan ini untuk maklumat lanjut tentang cara menyediakan akaun IBM Cloud® anda.

⚠️ Nota: Layani kunci API anda seperti kata laluan yang selamat. Lihat panduan Cloud setup untuk maklumat lanjut tentang penggunaan kunci API anda dalam persekitaran yang selamat dan tidak dipercayai.

Selain itu, jika anda adalah ahli universiti rangkaian rakan kongsi IBM, gunakan alamat e-mel institusi anda untuk ID IBM anda bagi menerima faedah rakan kongsi.

from qiskit_ibm_runtime import QiskitRuntimeService

# Save your API key and crn and have access to the quantum computers
your_api_key = "deleteThisAndPasteYourAPIKeyHere"
your_crn = "deleteThisAndPasteYourCRNHere"

QiskitRuntimeService.save_account(
    channel="ibm_cloud",
    token=your_api_key,
    instance=your_crn,
    overwrite=True
)

# Check that the account has been saved properly
service = QiskitRuntimeService()
service.saved_accounts()

# See backends you can use
service.backends()

3. Litar Kuantum Pertama Anda

Litar kuantum

Unit asas Qiskit ialah litar kuantum, iaitu satu siri arahan yang boleh digunakan oleh komputer kuantum untuk bekerja dengan bit maklumat kuantum, juga dikenali sebagai qubit. Qubit ini mempunyai sifat-sifat istimewa yang membolehkan komputer kuantum mendekati masalah secara berbeza daripada cara laptop atau iPhone anda melakukannya. Qiskit sedang berkembang pesat sebagai teknologi — walaupun anda masih boleh mereka bentuk litar kuantum anda secara manual dan memutuskan cara anda mahu menjalankannya (dan ada banyak sebab baik untuk berbuat demikian), IBM Quantum juga menyediakan alatan yang memudahkan proses tersebut. Demi pembelajaran, kita akan mereka bentuk litar yang sangat mudah dan menjalankannya pada simulator.

Kami mempercepatkan gambaran keseluruhan ini kerana, sejujurnya, kita boleh menghabiskan berjam-jam hanya untuk menjelaskan asas-asas maklumat dan pengiraan kuantum. Malah, IBM Quantum sudah melakukannya, menghasilkan kursus bertulis dan siri kuliah video yang didedikasikan untuk topik tersebut. Jika anda memerlukan ulang kaji, semak mereka!

from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector
from qiskit.visualization import plot_state_qsphere
from qiskit_aer import AerSimulator
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.visualization import array_to_latex
from qiskit.visualization import plot_distribution

import numpy as np
from numpy import sqrt

Operasi Asas pada qubit dan Pengukuran

Menulis keadaan qubit tunggal

Mari kita mulakan dengan melihat satu qubit tunggal. Perbezaan utama antara bit klasik, yang hanya boleh mengambil nilai 0 dan 1, adalah bahawa bit kuantum, atau qubit, boleh berada dalam keadaan $\vert0\rangle$ , $\vert1\rangle$ , serta kombinasi linear kedua-dua keadaan ini. Ciri ini dikenali sebagai superposisi, dan membolehkan kita menulis keadaan paling umum bagi sebuah qubit sebagai:

$\vert\psi\rangle = \sqrt{1-p}\vert0\rangle + e^{i \phi} \sqrt{p} \vert1\rangle$

Jika kita mengukur keadaan qubit ini, kita akan mendapati hasil $1$ dengan kebarangkalian $p$ , dan hasil $0$ dengan kebarangkalian $1-p$ . Seperti yang anda dapat lihat, jumlah kebarangkalian ialah $1$ , bermakna kita sememangnya akan mengukur sama ada $0$ atau $1$ , dan tiada hasil lain yang wujud.

Selain $p$ , anda mungkin perasan satu lagi parameter di atas. Pemboleh ubah $\phi$ menunjukkan fasa kuantum relatif antara dua keadaan $\vert0\rangle$ dan $\vert1\rangle$ . Seperti yang akan kita temui kemudian, fasa relatif ini cukup penting. Buat masa ini, cukuplah untuk diketahui bahawa fasa kuantum inilah yang membolehkan interferens antara keadaan kuantum, menghasilkan kemampuan kita untuk menulis algoritma kuantum bagi menyelesaikan tugas-tugas tertentu.

Memvisualisasikan keadaan kuantum

Kita memvisualisasikan keadaan kuantum sepanjang latihan ini menggunakan apa yang dikenali sebagai qsphere. Berikut adalah rupa qsphere untuk keadaan $\vert0\rangle$ dan $\vert1\rangle$ , masing-masing. Perhatikan bahawa bahagian paling atas sfera mewakili keadaan $\vert0\rangle$ , manakala bahagian bawah mewakili $\vert1\rangle$ .

#visualize |0>
sv=Statevector([1, 0])
plot_state_qsphere(sv)

Anda boleh membuat QSphere yang sama tepat menggunakan litar kuantum. Statevector yang kita gunakan di sini adalah dari keadaan $|0\rangle$ . Dalam Qiskit, qubit dimulakan dalam keadaan $|0\rangle$ . Cuba jalankan litar di bawah dan lihat jika anda boleh mendapatkan QSphere yang sama.

qc1 = QuantumCircuit(1)
sv=Statevector(qc1)
plot_state_qsphere(sv)

Sekarang mari kita visualisasikan keadaan $|1\rangle$ . Tidak hairanlah bahawa keadaan superposisi dengan fasa kuantum $\phi = 0$ dan kebarangkalian $p = 1/2$ (bermakna kemungkinan yang sama untuk mengukur 0 dan 1) ditunjukkan pada qsphere dengan dua titik. Namun, perhatikan juga bahawa saiz bulatan pada dua titik tersebut lebih kecil berbanding apabila kita hanya mempunyai $\vert0\rangle$ dan $\vert1\rangle$ di atas. Ini kerana saiz bulatan adalah berkadar dengan kebarangkalian mengukur masing-masing, yang kini dikurangkan separuh.

#visualize 1/sqrt(2)|0> + 1/sqrt(2)|1>

sv=Statevector([1/sqrt(2), 1/sqrt(2)])
plot_state_qsphere(sv)

Dalam kes keadaan superposisi, di mana fasa kuantum bukan sifar, qsphere membolehkan kita memvisualisasikan fasa tersebut dengan menukar warna blob yang berkenaan. Sebagai contoh, keadaan dengan $\phi = 90^\circ$ (darjah) dan kebarangkalian $p = 1/2$ ditunjukkan dalam qsphere di bawah.

sv=Statevector([1/sqrt(2), 1/sqrt(2)*1j])
plot_state_qsphere(sv)

Memanipulasi qubit

Qubit dimanipulasi dengan menggunakan quantum gate. Mari kita lihat gambaran keseluruhan gate-gate berbeza yang akan kita gunakan dalam latihan-latihan berikut.

Pertama, mari kita huraikan bagaimana kita boleh mengubah nilai $p$ untuk keadaan kuantum umum kita. Untuk berbuat demikian, kita akan menggunakan dua gate:

$X$ -gate: Gate ini membalikkan antara dua keadaan $\vert0\rangle$ dan $\vert1\rangle$ . Operasi ini sama dengan gate NOT klasik. Oleh sebab itu, $X$ -gate kadang-kadang dirujuk sebagai bit flip atau NOT gate. Secara matematik, $X$ gate mengubah $p$ kepada $1-p$ , jadi khususnya dari 0 kepada 1, dan sebaliknya.
$H$ -gate: Gate ini membolehkan kita pergi dari keadaan $\vert0\rangle$ ke keadaan $\frac{1}{\sqrt{2}}\left(\vert0\rangle + \vert1\rangle\right)$ . Keadaan ini juga dikenali sebagai $\vert+\rangle$ . Secara matematik, ini bermaksud pergi dari $p=0, \phi=0$ ke $p=1/2, \phi=0$ . Oleh sebab keadaan akhir qubit adalah superposisi antara $\vert0\rangle$ dan $\vert1\rangle$ , Hadamard gate mewakili operasi kuantum yang sebenar.

Perhatikan bahawa kedua-dua gate mengubah nilai $p$ , tetapi bukan $\phi$ . Nasib baik, kita boleh membayangkan tindakan gate-gate ini dengan mudah dengan melihat rajah di bawah.

Selepas kita dapat keadaan $\vert+\rangle$ , kita boleh mengubah fasa kuantum dengan menggunakan beberapa gate lain. Contohnya, gate $S$ menambah fasa sebanyak $90$ darjah kepada $\phi$ , manakala gate $Z$ menambah fasa sebanyak $180$ darjah kepada $\phi$ . Untuk menolak fasa sebanyak $90$ darjah, kita boleh menggunakan gate $S^\dagger$ , yang dibaca sebagai S-dagger, dan biasanya ditulis sebagai sdg. Akhir sekali, ada gate $Y$ yang menggunakan urutan gate $Z$ dan $X$ .

Anda boleh mencuba gate $X$ , $Y$ , $Z$ , $H$ , $S$ dan $S^\dagger$ untuk membiasakan diri dengan operasi-operasi berbeza dan bagaimana ia mempengaruhi keadaan qubit. Untuk berbuat demikian, anda boleh melawati Circuit Composer dan memulakan widget litar kita. Selepas melawati Circuit Composer, pilih gate untuk digunakan pada qubit, kemudian pilih qubit (dalam contoh pertama, satu-satunya qubit yang boleh dipilih ialah qubit 0). Perhatikan bagaimana keadaan yang sepadan berubah dengan setiap gate, serta penerangan keadaan tersebut. Ia juga akan memberikan anda kod yang mencipta litar kuantum yang sepadan dalam Qiskit.

Jika anda ingin mengetahui lebih lanjut tentang menghuraikan keadaan kuantum, operator Pauli, dan gate satu-Qubit lain, lihat Quantum Information dalam Single System dalam Kursus Basics of Quantum Information oleh John Watrous.

Practices: Quantum Circuits Using Single-Qubit gates

Berikut ialah empat latihan kecil untuk mencapai keadaan berbeza pada qsphere. Anda boleh sama ada menyelesaikannya dengan Circuit Composer dan menyalin-tampal kod yang diberikan ke dalam sel masing-masing untuk mencipta litar kuantum, atau anda boleh terus memasukkan kombinasi baris kod berikut ke dalam program untuk menggunakan gate-gate berbeza:

qc.x(0) # bit flip qc.y(0) # bit and phase flip qc.z(0) # phase flip qc.h(0) # superpostion qc.s(0) # quantum phase rotation by pi/2 (90 degrees) qc.sdg(0) # quantum phase rotation by -pi/2 (90 degrees)

'(0)' menunjukkan bahawa kita menggunakan gate ini pada qubit 'q0', iaitu qubit pertama (dan dalam kes ini satu-satunya).

Cuba untuk mencapai keadaan yang diberikan pada qsphere dalam setiap latihan berikut.

i) Mari mulakan dengan melakukan bit flip. Matlamatnya adalah untuk mencapai keadaan $\vert1\rangle$ bermula dari keadaan $\vert0\rangle$ .

def create_circuit():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

# check solution
qc2 = create_circuit()
state = Statevector(qc2)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

ii) Seterusnya, mari cipta superposisi. Matlamatnya adalah untuk mencapai keadaan $|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)$ .

def create_circuit2():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc3 = create_circuit2()
state = Statevector(qc3)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iii) Mari gabungkan kedua-duanya. Matlamatnya adalah untuk mencapai keadaan $|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)$ .

Bolehkah anda menggabungkan dua tugasan di atas untuk mendapatkan penyelesaian?

def create_circuit3():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc4 = create_circuit3()
state = Statevector(qc4)
plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

iv) Akhir sekali, kita beralih kepada nombor kompleks. Matlamatnya adalah untuk mencapai keadaan $|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)$

def create_circuit4():
    qc = QuantumCircuit(1)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc5 = create_circuit4()
state = Statevector(qc5)

plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True)

4. Kuiz Kuantum dengan Gate Berbilang Qubit

Bagus! Setelah anda memahami gate satu qubit, mari kita lihat gate yang beroperasi pada berbilang qubit. Di sini anda akan diminta untuk menyelesaikan 4 kuiz keadaan kuantum dengan menggabungkan gate satu qubit dan gate berbilang qubit. Gate asas pada dua qubit diberikan oleh

qc.cx(c,t) # controlled-X (= CNOT) gate with control qubit c and target qubit t qc.cz(c,t) # controlled-Z gate with control qubit c and target qubit t qc.swap(a,b) # SWAP gate that swaps the states of qubit a and qubit b

Jika anda ingin membaca lebih lanjut tentang pelbagai multi-qubit gate dan hubungan mereka, lawati Quantum Information bagi berbilang sistem, dalam Kursus Basics of Quantum Information John.

Perlu diambil perhatian bahawa untuk dua qubit, keadaan umum berbentuk $a|00\rangle + b |01\rangle + c |10\rangle + d|11\rangle$ , di mana $a$ , $b$ , $c$ , dan $d$ adalah nombor kompleks yang nilai mutlak kuasaduanya memberikan kebarangkalian untuk mengukur keadaan masing-masing; contohnya, $|a|^2$ ialah kebarangkalian untuk berakhir dalam keadaan '0' pada kedua-dua qubit. Ini bermakna kita kini boleh ada sehingga empat titik pada qsphere.

Kita mulakan dengan gate dua qubit yang paling asas, iaitu controlled-NOT (juga CNOT atau CX) gate. Di sini, seperti semua gate dua qubit terkawal, satu qubit dilabelkan sebagai "control", manakala yang lain dipanggil "target". Jika qubit control berada dalam keadaan $|0\rangle$ , ia menggunakan gate identiti $I$ pada target, iaitu tiada operasi dilakukan. Sebaliknya, jika qubit control berada dalam keadaan $|1\rangle$ , X-gate dilakukan pada qubit target. Oleh itu, dengan kedua-dua qubit dalam salah satu daripada dua keadaan klasik, $|0\rangle$ atau $|1\rangle$ , gate CNOT terhad kepada operasi klasik.

Situasi ini berubah dengan dramatik apabila kita mula-mula menggunakan Hadamard gate pada qubit control, membawanya ke dalam keadaan superposisi $|+\rangle$ . Tindakan gate CNOT pada input bukan klasik ini boleh menghasilkan keadaan yang sangat terjerat antara qubit control dan target. Jika qubit target pada mulanya berada dalam keadaan $|0\rangle$ , keadaan yang terhasil dilambangkan dengan $|\Phi^+\rangle$ , dan merupakan salah satu daripada apa yang dipanggil Bell states.

i) Bina Bell state $|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)$ .

Untuk keadaan ini kita akan ada kebarangkalian $\frac{1}{2}$ untuk mengukur "00" dan kebarangkalian $\frac{1}{2}$ untuk mengukur "11". Jadi, hasil kedua-dua qubit berkorelasi dengan sempurna.

def create_circuit5():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc6 = create_circuit5()
state = Statevector(qc6) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc6.draw(output='mpl') # we draw the circuit

Seterusnya, cuba cipta keadaan qubit yang berkorelasi terbalik dengan sempurna. Perhatikan tanda tolak di sini, yang menunjukkan fasa relatif antara dua keadaan.

ii) Bina Bell state $\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)$ .

def create_circuit6():
    qc = QuantumCircuit(2)
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    return qc

qc7 = create_circuit6()
state = Statevector(qc7) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc7.draw(output='mpl') # we draw the circuit

iii) Anda diberi litar kuantum yang diterangkan dalam fungsi di bawah. Tukar keadaan qubit pertama dan kedua untuk mendapatkan QSphere ini.

def create_circuit7():
    qc = QuantumCircuit(2)
    qc.rx(np.pi/3,0)
    qc.x(1)
    return qc

qc8 = create_circuit7()

#
#
# FILL YOUR CODE IN HERE
#
#

state = Statevector(qc8) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc8.draw(output='mpl') # we draw the circuit

iv) Tulis program dari awal yang mencipta keadaan GHZ (pada tiga qubit), $\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)$

def create_circuit8():
    #
    #
    # FILL YOUR CODE IN HERE
    #
    #
    #
    return qc

qc9 = create_circuit8()

pub4 = (qc9)

state = Statevector(qc9) # determine final state after running the circuit
display(array_to_latex(state))
display(plot_state_qsphere(state, show_state_labels=True, show_state_phases = True, use_degrees = True))
qc9.draw(output='mpl') # we draw the circuit

5. Jalankan litar anda dan lihat keputusan pengukuran dengan komputer kuantum sebenar

Sekarang kita sudah tahu cara membina litar kuantum untuk memanipulasi statevector qubit. Dan sudah tiba masanya untuk bahagian paling menyeronokkan: menjalankannya dan melihat outputnya! Di sini kita akan belajar cara moden dan berkesan untuk melaksanakan litar kita menggunakan Qiskit.

Pola Qiskit adalah rangka kerja umum untuk memecahkan masalah khusus domain dan mengkontekstualisasikan keupayaan yang diperlukan dalam peringkat-peringkat. Ini membolehkan kebolehkomposisian yang lancar bagi keupayaan baru yang dibangunkan oleh penyelidik IBM Quantum (dan lain-lain) serta membolehkan masa depan di mana tugas pengkomputeran kuantum dilaksanakan oleh infrastruktur pengkomputeran heterogen (CPU/GPU/QPU) yang berkuasa.

Empat langkah pola Qiskit adalah seperti berikut:

Peta masalah kepada quantum circuits dan operator
Optimumkan untuk perkakasan sasaran
Laksanakan pada perkakasan sasaran
Proses-lepas keputusan

Kita baru sahaja selesai Step 1: Mapping, dengan membina litar kuantum untuk menjana keadaan kuantum yang dikehendaki. Sekarang, mari kita telusuri langkah-langkah yang tinggal untuk melihat hasilnya.

Optimumkan

Di sini kita akan tetapkan Backend untuk menjalankan litar — anda boleh memilih least busy qpu daripada kumpulan qpu yang boleh anda akses, atau anda boleh memilih simulator sahaja jika masa GPU yang tinggal tidak mencukupi. Setelah memilih Backend, pass_manager akan transpile litar anda kepada set gate natif bagi Backend yang anda pilih dan mengoptimumkannya untuk anda supaya mendapat keputusan yang lebih baik. Anda boleh mengisytiharkan pass_manager dengan mudah menggunakan generate_preset_pass_manager dan menetapkan optimization_level, di mana nombor yang lebih tinggi menunjukkan lebih banyak langkah pengoptimuman.

Langkah seterusnya sangat menarik — kita akan jalankan quantum circuit menggunakan Qiskit Runtime!

Kita akan melakukannya menggunakan dua primitif Qiskit:

Sampler mengambil sampel daftar output daripada pelaksanaan satu atau lebih litar kuantum. Outputnya ialah kiraan pada pengukuran per-shot.
Estimator mengira nilai jangkaan satu atau lebih cerapan (observable) berkenaan dengan keadaan yang dijana oleh litar kuantum. Outputnya terdiri daripada nilai jangkaan bersama ralat piawainya.

Di sini, kita akan menggunakan Sampler untuk melaksanakan litar kita. Sel kod di bawah menunjukkan anda mula-mula menentukan Backend dan pass manager untuknya. Kemudian, ia akan menambah measurement pada semua litar dan mencipta array litar kuantum (pub) untuk dihantar kepada Sampler.

backend=service.least_busy()
#backend=AerSimulator()

pm = generate_preset_pass_manager(optimization_level=3, backend=backend)
sampler = Sampler(mode=backend)

pub = []
for qc in circ:
    qc.measure_all()
    pub.append(pm.run(qc))

Laksanakan

Mari kita laksanakan litar kita. Sekiranya barisan menunggu di awan panjang, cetak dan simpan job_id untuk kegunaan kemudian dan semak job_status. Selepas anda melihat status kerja bertukar kepada Done, dapatkan semula keputusan kerja.

job = sampler.run(pub)
job_id = job.job_id()
print(job_id)
job.status()

job_retrived = service.job(job_id)
result = job.result()

Proses-Lepas

Langkah terakhir adalah untuk mentafsir visualisasi bagi memahami keadaan kuantum yang kita cipta. Sebelum memplot beberapa graf, mari kita kumpulkan semua kiraan daripada semua litar. Kemudian kita akan membuat 4 plot dengan mengkategorikan litar.

result = job.result()
counts_all = [result[k].data.meas.get_counts() for k in range(9)]

Keadaan qubit Tunggal

plot_distribution([counts_all[0], counts_all[1]], legend =['qc1', 'qc2'])

Keadaan Satu qubit yang Tersuperposisi

plot_distribution([counts_all[2], counts_all[3], counts_all[4]], legend =['qc3', 'qc4', 'qc5'])

Keadaan Dua qubit

plot_distribution([counts_all[5], counts_all[6], counts_all[7]],legend =['qc6', 'qc7', 'qc8'] )

Keadaan Tiga qubit

plot_distribution(counts_all[8], legend=['qc9'])

Cabaran Lanjutan

Adakah anda jumpa sebarang hingar dalam keputusan eksperimen Backend sebenar? Menghapuskan hingar qubit adalah salah satu bidang penyelidikan yang aktif. Cuba pelbagai pilihan pengurangan dan penindasan ralat Qiskit Runtime untuk melihat bagaimana hingar dalam keputusan pelaksanaan berubah! (Nota) Pilihan-pilihan ini memerlukan lebih banyak masa QPU.

Maklumat Tambahan

import qiskit, qiskit_ibm_runtime

print("Qiskit version:", qiskit.version.get_version_info())
print("Qiskit Runtime version:", qiskit_ibm_runtime.__version__)

Qiskit version: 2.1.1
Qiskit Runtime version: 0.40.1

Dicipta oleh: Sophy Shin

Disemak oleh: Nate Earnest-Noble

This is licensed under the Apache License, Version 2.0. You may obtain a copy of this license in the LICENSE file in the root directory of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.

Sebarang pengubahsuaian atau kerja terbitan daripada ini mesti mengekalkan notis hak cipta ini, dan fail yang diubah suai perlu membawa notis yang menunjukkan bahawa fail tersebut telah diubah daripada yang asal.

1. Perkara Pertama Dahulu: Qiskit​

Apa itu Qiskit​

Pasang Qiskit​

Penyelesaian Masalah​

2. Sediakan Akaun IBM Cloud Anda ​

3. Litar Kuantum Pertama Anda​

Litar kuantum​

Operasi Asas pada qubit dan Pengukuran​

Menulis keadaan qubit tunggal​

Memvisualisasikan keadaan kuantum​

Memanipulasi qubit​

Practices: Quantum Circuits Using Single-Qubit gates​

i) Mari mulakan dengan melakukan bit flip. Matlamatnya adalah untuk mencapai keadaan ∣1⟩\vert1\rangle∣1⟩ bermula dari keadaan ∣0⟩\vert0\rangle∣0⟩.​

ii) Seterusnya, mari cipta superposisi. Matlamatnya adalah untuk mencapai keadaan ∣+⟩=12(∣0⟩+∣1⟩)|+\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle + |1\rangle\right)∣+⟩=2​1​(∣0⟩+∣1⟩).​

iii) Mari gabungkan kedua-duanya. Matlamatnya adalah untuk mencapai keadaan ∣−⟩=12(∣0⟩−∣1⟩)|-\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - |1\rangle\right)∣−⟩=2​1​(∣0⟩−∣1⟩).​

iv) Akhir sekali, kita beralih kepada nombor kompleks. Matlamatnya adalah untuk mencapai keadaan ∣↺⟩=12(∣0⟩−i∣1⟩)|\circlearrowleft\rangle = \frac{1}{\sqrt{2}}\left(|0\rangle - i|1\rangle\right)∣↺⟩=2​1​(∣0⟩−i∣1⟩)​

4. Kuiz Kuantum dengan Gate Berbilang Qubit​

i) Bina Bell state ∣Φ+⟩=12(∣00⟩+∣11⟩)|\Phi^+\rangle = \frac{1}{\sqrt{2}}\left(|00\rangle + |11\rangle\right)∣Φ+⟩=2​1​(∣00⟩+∣11⟩).​

ii) Bina Bell state ∣Ψ−⟩=12(∣01⟩−∣10⟩)\vert\Psi^-\rangle = \frac{1}{\sqrt{2}}\left(\vert01\rangle - \vert10\rangle\right)∣Ψ−⟩=2​1​(∣01⟩−∣10⟩).​

iii) Anda diberi litar kuantum yang diterangkan dalam fungsi di bawah. Tukar keadaan qubit pertama dan kedua untuk mendapatkan QSphere ini.​

iv) Tulis program dari awal yang mencipta keadaan GHZ (pada tiga qubit), ∣GHZ⟩=12(∣000⟩+∣111⟩)\vert \text{GHZ}\rangle = \frac{1}{\sqrt{2}} \left(|000\rangle + |111 \rangle \right)∣GHZ⟩=2​1​(∣000⟩+∣111⟩)​

5. Jalankan litar anda dan lihat keputusan pengukuran dengan komputer kuantum sebenar​

Optimumkan​

Laksanakan​

Proses-Lepas​

Cabaran Lanjutan​

Maklumat Tambahan​